package messages

import (
	"errors"
	"time"

	"github.com/asynkron/protoactor-go/actor"
)

// SystemCommand 是所有系统命令的基础接口
type SystemCommand interface {
	isSystemCommand()
}

// SystemResponse 是所有系统响应的基础接口
type SystemResponse interface {
	isSystemResponse()
}

// SpawnChildCommand 是生成子actor的命令
type SpawnChildCommand struct {
	// Name 是子actor的名称
	Name string
	// Props 是子actor的属性
	Props *actor.Props
}

func (*SpawnChildCommand) isSystemCommand() {}

// SpawnChildResponse 是对SpawnChildCommand的响应
type SpawnChildResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误消息
	Error string
	// PID 是生成的actor的PID
	PID *actor.PID
}

func (*SpawnChildResponse) isSystemResponse() {}

// StopChildCommand 是停止子actor的命令
type StopChildCommand struct {
	// Name 是子actor的名称
	Name string
}

func (*StopChildCommand) isSystemCommand() {}

// StopChildResponse 是对StopChildCommand的响应
type StopChildResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误消息
	Error string
}

func (*StopChildResponse) isSystemResponse() {}

// GetChildrenCommand 是获取所有子actor的命令
type GetChildrenCommand struct{}

func (*GetChildrenCommand) isSystemCommand() {}

// GetChildrenResponse 是对GetChildrenCommand的响应
type GetChildrenResponse struct {
	// Children 是子actor名称到PID的映射
	Children map[string]*actor.PID
}

func (*GetChildrenResponse) isSystemResponse() {}

// RestartCommand 是重启actor的命令
type RestartCommand struct{}

func (*RestartCommand) isSystemCommand() {}

// SystemCommandMsg 是通用系统命令
type SystemCommandMsg struct {
	// Command 是要执行的命令
	Command string
	// Params 是命令参数
	Params map[string]interface{}
}

func (*SystemCommandMsg) isSystemCommand() {}

// ErrorMessage 是报告错误的消息
type ErrorMessage struct {
	// ActorID 是报告错误的actor的ID
	ActorID string
	// Error 是被报告的错误
	Error error
	// Severity 是错误严重性
	Severity string
	// Timestamp 是错误发生时间
	Timestamp time.Time
	// Context 包含额外的错误上下文
	Context map[string]interface{}
}

// CriticalError 表示应该停止actor的严重错误
type CriticalError struct {
	// Message 是错误消息
	Message string
	// Cause 是底层错误
	Cause error
}

// Error 返回错误消息
func (e *CriticalError) Error() string {
	if e.Cause != nil {
		return e.Message + ": " + e.Cause.Error()
	}
	return e.Message
}

// Unwrap 返回底层错误
func (e *CriticalError) Unwrap() error {
	return e.Cause
}

// TemporaryError 表示应该重启actor的临时错误
type TemporaryError struct {
	// Message 是错误消息
	Message string
	// Cause 是底层错误
	Cause error
	// RetryCount 是重试次数
	RetryCount int
}

// Error 返回错误消息
func (e *TemporaryError) Error() string {
	if e.Cause != nil {
		return e.Message + " (retry " + string(e.RetryCount) + "): " + e.Cause.Error()
	}
	return e.Message + " (retry " + string(e.RetryCount) + ")"
}

// Unwrap 返回底层错误
func (e *TemporaryError) Unwrap() error {
	return e.Cause
}

// NewCriticalError 创建新的严重错误
func NewCriticalError(message string, cause error) *CriticalError {
	return &CriticalError{
		Message: message,
		Cause:   cause,
	}
}

// NewTemporaryError 创建新的临时错误
func NewTemporaryError(message string, cause error, retryCount int) *TemporaryError {
	return &TemporaryError{
		Message:    message,
		Cause:      cause,
		RetryCount: retryCount,
	}
}

// DataMessage 是包含数据的消息
type DataMessage struct {
	// MessageID 是消息的唯一ID
	MessageID string
	// Data 是消息数据
	Data []byte
	// Metadata 包含额外的消息元数据
	Metadata map[string]string
	// Timestamp 是消息创建时间
	Timestamp time.Time
	// SourceID 是源actor的ID
	SourceID string
	// DestinationID 是目标actor的ID
	DestinationID string
}

// SaveStateCommand 是保存状态的命令
type SaveStateCommand struct {
	// Key 是状态键
	Key string
	// State 是要保存的状态
	State interface{}
}

func (*SaveStateCommand) isSystemCommand() {}

// SaveStateResponse 是对SaveStateCommand的响应
type SaveStateResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误
	Error error
}

func (*SaveStateResponse) isSystemResponse() {}

// LoadStateCommand 是加载状态的命令
type LoadStateCommand struct {
	// Key 是状态键
	Key string
}

func (*LoadStateCommand) isSystemCommand() {}

// LoadStateResponse 是对LoadStateCommand的响应
type LoadStateResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误
	Error error
	// State 是加载的状态
	State interface{}
}

func (*LoadStateResponse) isSystemResponse() {}

// CreateCheckpointCommand 是创建检查点的命令
type CreateCheckpointCommand struct {
	// ID 是检查点ID
	ID string
}

func (*CreateCheckpointCommand) isSystemCommand() {}

// CreateCheckpointResponse 是对CreateCheckpointCommand的响应
type CreateCheckpointResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误
	Error error
}

func (*CreateCheckpointResponse) isSystemResponse() {}

// RestoreFromCheckpointCommand 是从检查点恢复的命令
type RestoreFromCheckpointCommand struct {
	// ID 是检查点ID
	ID string
}

func (*RestoreFromCheckpointCommand) isSystemCommand() {}

// RestoreFromCheckpointResponse 是对RestoreFromCheckpointCommand的响应
type RestoreFromCheckpointResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误
	Error error
}

func (*RestoreFromCheckpointResponse) isSystemResponse() {}

// SubscribeToStateChangesCommand 是订阅状态变化的命令
type SubscribeToStateChangesCommand struct {
	// Key 是要订阅的状态键
	Key string
}

func (*SubscribeToStateChangesCommand) isSystemCommand() {}

// SubscribeToStateChangesResponse 是对SubscribeToStateChangesCommand的响应
type SubscribeToStateChangesResponse struct {
	// Success 表示操作是否成功
	Success bool
	// Error 是操作失败时的错误
	Error error
}

func (*SubscribeToStateChangesResponse) isSystemResponse() {}

// StateChangedEvent 是状态变化的事件
type StateChangedEvent struct {
	// Key 是状态键
	Key string
	// NewState 是新状态
	NewState interface{}
	// OldState 是旧状态
	OldState interface{}
	// Timestamp 是状态变化时间
	Timestamp time.Time
}

// Common errors
var (
	// ErrNotFound 在资源未找到时返回
	ErrNotFound = errors.New("resource not found")
	// ErrAlreadyExists 在资源已存在时返回
	ErrAlreadyExists = errors.New("resource already exists")
	// ErrInvalidState 在当前状态下操作无效时返回
	ErrInvalidState = errors.New("invalid state for operation")
	// ErrTimeout 在操作超时时返回
	ErrTimeout = errors.New("operation timed out")
	// ErrCancelled 在操作被取消时返回
	ErrCancelled = errors.New("operation cancelled")
)
